{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# IVF算法\n",
        "\n",
        "## 🔎 算法原理分步详解​\n",
        "\n",
        "第一阶段：索引构建（建库与分类）​​\n",
        "构建索引的目的是为数据建立一个高效的结构化目录，这个过程通常是离线完成的。\n",
        "**​1.​聚类训练（Clustering）​​**\n",
        "使用聚类算法（最常用的是 ​​K-Means​​）将所有向量划分成 nlist个簇（clusters）。nlist是一个关键参数，它决定了空间划分的粒度。每个簇都有一个中心点，称为​​质心（centroid）​​。所有这些质心构成了一个“质心表”，相当于图书馆的​​总分类目录​​。\n",
        "**​2.​向量分配（Assignment）​​**\n",
        "遍历数据集中的每一个向量，计算它与所有质心的距离（如欧氏距离）。将每个向量分配到​​距离它最近的那个质心​​所对应的簇中。\n",
        "**3.​​形成倒排列表（Inverted Lists）​​**\n",
        "为每一个簇建立一个​​倒排列表​​（或称“张贴列表”）。这个列表就像图书馆每个分类书架上的图书清单，它记录了所有属于这个簇的​​向量的ID以及向量本身​​（或它的压缩表示）。至此，索引构建完成。\n",
        "\n",
        "第二阶段：查询处理（快速检索）​​\n",
        "当一个新的查询向量到来时，IVF利用已构建好的索引进行快速检索。\n",
        "**​1.​定位最近簇（Coarse Quantization）​​**\n",
        "计算查询向量与​​质心表​​中所有 nlist个质心的距离。\n",
        "\n",
        "**2.​选择候选簇（nprobe 参数控制）​​**\n",
        "根据上一步的距离结果，选择距离最近的 nprobe个簇作为候选簇。​​nprobe是IVF算法中最关键的调优参数之一​​：\n",
        "nprobe越小，搜索范围越小，​​速度越快，但可能漏掉一些真正近邻（召回率降低）​​。\n",
        "nprobe越大，搜索范围越大，​​召回率越高，但计算量增大，速度变慢​​。\n",
        "\n",
        "**​3.​簇内精细比较（Fine Comparison）​​**\n",
        "在选定的 nprobe个候选簇的倒排列表中，进行精细的距离计算。\n",
        "具体方式取决于IVF的变体：\n",
        "  - IVF-Flat：直接使用原始的、未压缩的向量与查询向量进行精确距离计算。这种方式精度最高，但内存占用也最大。 \n",
        "  - IVF-PQ：为了进一步节省内存和加速计算，会对簇内向量使用乘积量化（Product Quantization） 进行压缩。搜索时使用近似距离计算，这是一种用少量精度换取巨大存储和计算效率提升的策略。\n",
        "\n",
        "**​4.​结果合并与返回​​**\n",
        "将所有候选簇中的向量根据与查询向量的距离进行排序，最终返回 Top-K 个最相似的向量作为结果。\n",
        "\n",
        "VF的性能和效果很大程度上取决于两个核心参数的设置，它们就像这个系统的“调速器”：\n",
        "\n",
        "- nlist（聚类数）：决定了空间的划分粒度。nlist 越大，搜索范围越大，召回率越高；但同时也增加了计算量。\n",
        "- nprobe（候选簇数）：控制了搜索的范围。nprobe 越小，搜索越快，但可能会漏掉一些近邻；nprobe 越大，搜索范围越大，召回率越高，但计算量增大。\n",
        "\n",
        "## IVF算法实现\n",
        "\n",
        "🧠 IVF算法Python实现\n",
        "\n",
        "**首先，我们导入必要的库：**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.metrics.pairwise import cosine_similarity, euclidean_distances\n",
        "import matplotlib.pyplot as plt\n",
        "import time\n",
        "from collections import defaultdict\n",
        "plt.rcParams['font.sans-serif'] = ['Hiragino Sans GB', 'STHeiti', 'PingFang SC', 'Microsoft YaHei', 'Arial Unicode MS', 'DejaVu Sans']\n",
        "plt.rcParams['axes.unicode_minus'] = False\n",
        "\n",
        "# 设置随机种子以保证结果可重现\n",
        "np.random.seed(42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**📊 第一步：生成模拟数据**\n",
        "\n",
        "我们创建一些简单的二维数据，方便可视化理解："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "数据形状: (1000, 2)\n"
          ]
        }
      ],
      "source": [
        "def generate_sample_data(n_samples=1000, dim=2):\n",
        "    \"\"\"生成示例数据：三个明显分离的高斯分布簇\"\"\"\n",
        "    # 第一个簇\n",
        "    cluster1 = np.random.normal(loc=[2, 2], scale=0.5, size=(n_samples//3, dim))\n",
        "    # 第二个簇  \n",
        "    cluster2 = np.random.normal(loc=[8, 3], scale=0.6, size=(n_samples//3, dim))\n",
        "    # 第三个簇\n",
        "    cluster3 = np.random.normal(loc=[5, 8], scale=0.4, size=(n_samples - 2*(n_samples//3), dim))\n",
        "    \n",
        "    data = np.vstack([cluster1, cluster2, cluster3])\n",
        "    return data\n",
        "\n",
        "# 生成数据\n",
        "data = generate_sample_data()\n",
        "print(f\"数据形状: {data.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**⚙️ 第二步：手动实现K-means聚类**\n",
        "\n",
        "这是IVF算法的核心预处理步骤："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "class SimpleKMeans:\n",
        "    \"\"\"简化的K-means实现用于IVF聚类\"\"\"\n",
        "    \n",
        "    def __init__(self, n_clusters=3, max_iters=100):\n",
        "        self.n_clusters = n_clusters\n",
        "        self.max_iters = max_iters\n",
        "        self.centroids = None\n",
        "        self.labels_ = None\n",
        "    \n",
        "    def fit(self, X):\n",
        "        n_samples, n_features = X.shape\n",
        "        \n",
        "        # 1. 随机初始化质心\n",
        "        random_indices = np.random.choice(n_samples, self.n_clusters, replace=False)\n",
        "        self.centroids = X[random_indices]\n",
        "        \n",
        "        for iteration in range(self.max_iters):\n",
        "            # 2. 分配每个点到最近的质心\n",
        "            distances = euclidean_distances(X, self.centroids)\n",
        "            labels = np.argmin(distances, axis=1)\n",
        "            \n",
        "            # 3. 更新质心位置\n",
        "            new_centroids = np.array([X[labels == i].mean(axis=0) for i in range(self.n_clusters)])\n",
        "            \n",
        "            # 检查收敛\n",
        "            if np.allclose(self.centroids, new_centroids):\n",
        "                break\n",
        "                \n",
        "            self.centroids = new_centroids\n",
        "        \n",
        "        self.labels_ = labels\n",
        "        return self"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**📁 第三步：实现倒排文件索引(IVF)**\n",
        "\n",
        "现在实现完整的IVF索引结构："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "class SimpleIVF:\n",
        "    \"\"\"简化的IVF实现\"\"\"\n",
        "    \n",
        "    def __init__(self, n_clusters=3, n_probe=2):\n",
        "        self.n_clusters = n_clusters\n",
        "        self.n_probe = n_probe  # 搜索时探测的簇数量\n",
        "        self.kmeans = None\n",
        "        self.inverted_lists = None  # 倒排列表\n",
        "        self.centroids = None\n",
        "        self.is_trained = False\n",
        "    \n",
        "    def train(self, data):\n",
        "        \"\"\"训练IVF索引：对数据进行聚类\"\"\"\n",
        "        print(\"开始训练IVF索引...\")\n",
        "        self.kmeans = SimpleKMeans(n_clusters=self.n_clusters)\n",
        "        self.kmeans.fit(data)\n",
        "        self.centroids = self.kmeans.centroids\n",
        "        self.is_trained = True\n",
        "        print(f\"训练完成，得到{self.n_clusters}个簇\")\n",
        "    \n",
        "    def build_index(self, data):\n",
        "        \"\"\"构建倒排索引\"\"\"\n",
        "        if not self.is_trained:\n",
        "            self.train(data)\n",
        "        \n",
        "        # 初始化倒排列表\n",
        "        self.inverted_lists = defaultdict(list)\n",
        "        \n",
        "        # 将每个向量分配到最近的簇\n",
        "        distances = euclidean_distances(data, self.centroids)\n",
        "        labels = np.argmin(distances, axis=1)\n",
        "        \n",
        "        # 构建倒排列表：簇ID -> 该簇中所有向量的索引\n",
        "        for idx, label in enumerate(labels):\n",
        "            self.inverted_lists[label].append(idx)\n",
        "        \n",
        "        print(\"倒排索引构建完成「展示前5个簇」:\")\n",
        "        for i, (cluster_id, items) in enumerate(self.inverted_lists.items()):\n",
        "            if i >= 5:\n",
        "                break\n",
        "            print(f\"  簇{cluster_id}: {len(items)}个向量\")\n",
        "    \n",
        "    def search(self, query, k=5, data=None):\n",
        "        \"\"\"IVF搜索：先找最近的簇，然后在簇内搜索\"\"\"\n",
        "        if data is None:\n",
        "            data = self.data\n",
        "            \n",
        "        # 1. 粗略搜索：找到最近的n_probe个簇\n",
        "        distances_to_centroids = euclidean_distances([query], self.centroids)[0]\n",
        "        nearest_cluster_indices = np.argsort(distances_to_centroids)[:self.n_probe]\n",
        "        \n",
        "        # 2. 精细搜索：在选中的簇内进行暴力搜索\n",
        "        candidate_indices = []\n",
        "        for cluster_idx in nearest_cluster_indices:\n",
        "            candidate_indices.extend(self.inverted_lists[cluster_idx])\n",
        "        \n",
        "        if not candidate_indices:\n",
        "            return [], []\n",
        "        \n",
        "        # 在候选向量中计算距离\n",
        "        candidate_vectors = data[candidate_indices]\n",
        "        distances = euclidean_distances([query], candidate_vectors)[0]\n",
        "        \n",
        "        # 获取最近的k个结果\n",
        "        if k > len(distances):\n",
        "            k = len(distances)\n",
        "            \n",
        "        nearest_indices_within_candidates = np.argsort(distances)[:k]\n",
        "        \n",
        "        # 映射回原始索引\n",
        "        final_indices = [candidate_indices[i] for i in nearest_indices_within_candidates]\n",
        "        final_distances = distances[nearest_indices_within_candidates]\n",
        "        \n",
        "        return final_indices, final_distances\n",
        "    \n",
        "    def brute_force_search(self, query, k=5, data=None):\n",
        "        \"\"\"暴力搜索作为对比基准\"\"\"\n",
        "        if data is None:\n",
        "            data = self.data\n",
        "            \n",
        "        distances = euclidean_distances([query], data)[0]\n",
        "        nearest_indices = np.argsort(distances)[:k]\n",
        "        return nearest_indices, distances[nearest_indices]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**🔍 第四步：算法实现**\n",
        "\n",
        "让我们用一个完整的例子来展示IVF的工作原理："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "============================================================\n",
            "IVF算法演示\n",
            "============================================================\n",
            "生成: 50,000个二维数据点\n",
            "\n",
            "IVF参数配置:\n",
            "聚类数量 (n_clusters): 111\n",
            "搜索簇数 (n_probe): 13\n",
            "开始训练IVF索引...\n",
            "训练完成，得到111个簇\n",
            "倒排索引构建完成「展示前5个簇」:\n",
            "  簇23: 314个向量\n",
            "  簇43: 348个向量\n",
            "  簇59: 166个向量\n",
            "  簇6: 687个向量\n",
            "  簇32: 682个向量\n",
            "\n",
            "查询点: [5 5]\n",
            "\n",
            "搜索结果对比:\n",
            "IVF搜索  - 找到10个最近邻, 耗时: 0.001200秒\n",
            "暴力搜索 - 找到10个最近邻, 耗时: 0.004839秒\n",
            "\n",
            "速度提升: 4.03倍\n",
            "搜索比例: 10.0% (5,011/50,000)\n",
            "\n",
            "最近邻索引 (IVF): [26738, 18695, 49731, 35576, 47988, 31669, 44706, 41498, 35176, 44646]\n",
            "最近邻索引 (暴力): [26738 18695 49731 35576 47988 31669 44706 41498 35176 44646]\n",
            "召回率: 100.0% (10/10)\n"
          ]
        }
      ],
      "source": [
        "def demonstrate_ivf(data_size=50000, dimensions=2):\n",
        "    \"\"\"完整演示IVF算法\"\"\"\n",
        "    print(\"=\" * 60)\n",
        "    print(\"IVF算法演示\")\n",
        "    print(\"=\" * 60)\n",
        "    \n",
        "    # 1. 生成数据\n",
        "    data = generate_sample_data(data_size, dimensions)\n",
        "    print(f\"生成: {len(data):,}个二维数据点\")\n",
        "    \n",
        "    # 2. 创建并训练IVF索引\n",
        "    print(\"\\nIVF参数配置:\")\n",
        "    n_clusters = int(np.sqrt(len(data)) / 2)  # 约158个簇\n",
        "    n_probe = max(2, n_clusters // 8)         # 搜索约12.5%的簇\n",
        "    ivf = SimpleIVF(n_clusters=n_clusters, n_probe=n_probe)\n",
        "    print(f\"聚类数量 (n_clusters): {n_clusters}\")\n",
        "    print(f\"搜索簇数 (n_probe): {n_probe}\")\n",
        "    \n",
        "    ivf.data = data  # 保存数据引用\n",
        "    \n",
        "    build_start = time.time()\n",
        "    ivf.build_index(data)\n",
        "    \n",
        "    # 3. 选择查询点\n",
        "    query_point = np.array([5, 5])\n",
        "    print(f\"\\n查询点: {query_point}\")\n",
        "    \n",
        "    # 4. 性能对比测试\n",
        "    k = 10\n",
        "    \n",
        "    # IVF搜索 (多次测试取平均)\n",
        "    ivf_times = []\n",
        "    for _ in range(5):\n",
        "        start_time = time.time()\n",
        "        ivf_indices, ivf_distances = ivf.search(query_point, k=k, data=data)\n",
        "        ivf_times.append(time.time() - start_time)\n",
        "    ivf_time = np.mean(ivf_times)\n",
        "    \n",
        "    # 暴力搜索\n",
        "    bf_times = []\n",
        "    for _ in range(3):  # 暴力搜索较慢，测试次数少一些\n",
        "        start_time = time.time()\n",
        "        bf_indices, bf_distances = ivf.brute_force_search(query_point, k=k, data=data)\n",
        "        bf_times.append(time.time() - start_time)\n",
        "    bf_time = np.mean(bf_times)\n",
        "    \n",
        "\n",
        "    # 5. 显示结果\n",
        "    print(f\"\\n搜索结果对比:\")\n",
        "    print(f\"IVF搜索  - 找到{len(ivf_indices)}个最近邻, 耗时: {ivf_time:.6f}秒\")\n",
        "    print(f\"暴力搜索 - 找到{len(bf_indices)}个最近邻, 耗时: {bf_time:.6f}秒\")\n",
        "    \n",
        "    print(f\"\\n速度提升: {bf_time/ivf_time:.2f}倍\")\n",
        "    \n",
        "    # 计算搜索效率\n",
        "    total_candidates = sum(len(ivf.inverted_lists[i]) for i in \n",
        "                          np.argsort(euclidean_distances([query_point], ivf.centroids)[0])[:n_probe])\n",
        "    search_ratio = total_candidates / len(data)\n",
        "    print(f\"搜索比例: {search_ratio:.1%} ({total_candidates:,}/{len(data):,})\")\n",
        "    \n",
        "    print(f\"\\n最近邻索引 (IVF): {ivf_indices}\")\n",
        "    print(f\"最近邻索引 (暴力): {bf_indices}\")\n",
        "    \n",
        "    # 计算召回率\n",
        "    intersection = set(ivf_indices) & set(bf_indices)\n",
        "    recall = len(intersection) / len(bf_indices)\n",
        "    print(f\"召回率: {recall:.1%} ({len(intersection)}/{len(bf_indices)})\")\n",
        "    \n",
        "    return ivf, data, query_point, ivf_indices, bf_indices\n",
        "\n",
        "ivf, data, query, ivf_results, bf_results = demonstrate_ivf()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**📈 第五步：可视化结果**\n",
        "\n",
        "让我们用图形化的方式展示IVF的工作原理："
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "============================================================\n",
            "IVF算法演示\n",
            "============================================================\n",
            "生成: 100个二维数据点\n",
            "\n",
            "IVF参数配置:\n",
            "聚类数量 (n_clusters): 5\n",
            "搜索簇数 (n_probe): 2\n",
            "开始训练IVF索引...\n",
            "训练完成，得到5个簇\n",
            "倒排索引构建完成「展示前5个簇」:\n",
            "  簇0: 18个向量\n",
            "  簇2: 15个向量\n",
            "  簇3: 20个向量\n",
            "  簇4: 13个向量\n",
            "  簇1: 34个向量\n",
            "\n",
            "查询点: [5 5]\n",
            "\n",
            "搜索结果对比:\n",
            "IVF搜索  - 找到10个最近邻, 耗时: 0.000558秒\n",
            "暴力搜索 - 找到10个最近邻, 耗时: 0.000524秒\n",
            "\n",
            "速度提升: 0.94倍\n",
            "搜索比例: 54.0% (54/100)\n",
            "\n",
            "最近邻索引 (IVF): [37, 63, 61, 88, 69, 92, 93, 90, 96, 87]\n",
            "最近邻索引 (暴力): [37 63 61 88 69 92 93 90 96 87]\n",
            "召回率: 100.0% (10/10)\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x1000 with 6 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "IVF算法统计:\n",
            "数据量: 100 个向量\n",
            "聚类数: 5 个簇\n",
            "搜索簇: 2 个簇\n",
            "候选向量: 54 个 (54.0%)\n",
            "召回率: 100.0%\n"
          ]
        }
      ],
      "source": [
        "def visualize_ivf(ivf, data, query, ivf_results, bf_results):\n",
        "    \"\"\"IVF算法可视化\"\"\"\n",
        "    plt.figure(figsize=(15, 10))\n",
        "    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD']\n",
        "    \n",
        "    # 计算查询相关信息\n",
        "    distances_to_centroids = euclidean_distances([query], ivf.centroids)[0]\n",
        "    nearest_cluster_indices = np.argsort(distances_to_centroids)[:ivf.n_probe]\n",
        "    \n",
        "    # 1. 原始数据分布\n",
        "    plt.subplot(2, 3, 1)\n",
        "    plt.scatter(data[:, 0], data[:, 1], c='lightblue', alpha=0.6, s=20, label='数据点')\n",
        "    plt.title('1. 原始数据分布', fontweight='bold')\n",
        "    plt.legend(fontsize=8)\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    # 2. K-means聚类\n",
        "    plt.subplot(2, 3, 2)\n",
        "    for cluster_id, indices in ivf.inverted_lists.items():\n",
        "        cluster_data = data[indices]\n",
        "        plt.scatter(cluster_data[:, 0], cluster_data[:, 1], \n",
        "                   c=colors[cluster_id % len(colors)], alpha=0.7, s=25,\n",
        "                   label=f'簇{cluster_id}')\n",
        "    \n",
        "    plt.scatter(ivf.centroids[:, 0], ivf.centroids[:, 1], \n",
        "               c='black', marker='X', s=100, linewidths=2, label='质心')\n",
        "    plt.title('2. K-means聚类', fontweight='bold')\n",
        "    plt.legend(fontsize=8)\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    # 3. 粗略搜索\n",
        "    plt.subplot(2, 3, 3)\n",
        "    \n",
        "    # 背景：显示所有数据点（淡化）\n",
        "    plt.scatter(data[:, 0], data[:, 1], c='lightgray', alpha=0.2, s=10)\n",
        "    \n",
        "    # 显示所有质心，用不同透明度区分选中和未选中\n",
        "    selected_centroids = set(nearest_cluster_indices)\n",
        "    \n",
        "    for i, centroid in enumerate(ivf.centroids):\n",
        "        if i in selected_centroids:\n",
        "            # 选中的质心：高亮显示\n",
        "            plt.scatter(centroid[0], centroid[1], c='red', marker='X', \n",
        "                       s=120, linewidths=2, edgecolors='darkred', alpha=0.9)\n",
        "            # 显示到查询点的距离线\n",
        "            plt.plot([query[0], centroid[0]], [query[1], centroid[1]], \n",
        "                    'r-', alpha=0.8, linewidth=2)\n",
        "            # 标注距离值\n",
        "            dist = np.linalg.norm(query - centroid)\n",
        "            mid_x, mid_y = (query[0] + centroid[0])/2, (query[1] + centroid[1])/2\n",
        "            plt.annotate(f'{dist:.1f}', (mid_x, mid_y), \n",
        "                        xytext=(0, 10), textcoords='offset points',\n",
        "                        fontsize=8, ha='center', color='red', fontweight='bold',\n",
        "                        bbox=dict(boxstyle='round,pad=0.2', facecolor='white', alpha=0.8))\n",
        "        else:\n",
        "            # 未选中的质心：淡化显示\n",
        "            plt.scatter(centroid[0], centroid[1], c='gray', marker='X', \n",
        "                       s=80, alpha=0.4, linewidths=1)\n",
        "            # 显示到查询点的距离线（虚线）\n",
        "            plt.plot([query[0], centroid[0]], [query[1], centroid[1]], \n",
        "                    'gray', linestyle=':', alpha=0.3, linewidth=1)\n",
        "    \n",
        "    # 查询点\n",
        "    plt.scatter(query[0], query[1], c='#FFD93D', marker='*', s=200, \n",
        "               edgecolors='black', linewidth=2, label='查询点', zorder=10)\n",
        "    \n",
        "    # 添加选择说明\n",
        "    plt.title(f'3. 粗略搜索：选择最近的{ivf.n_probe}个质心', fontweight='bold')\n",
        "    \n",
        "    # 创建图例\n",
        "    from matplotlib.lines import Line2D\n",
        "    legend_elements = [\n",
        "        Line2D([0], [0], marker='*', color='w', markerfacecolor='#FFD93D', \n",
        "               markersize=12, markeredgecolor='black', label='查询点'),\n",
        "        Line2D([0], [0], marker='X', color='w', markerfacecolor='red', \n",
        "               markersize=10, markeredgecolor='darkred', label='选中质心'),\n",
        "        Line2D([0], [0], marker='X', color='w', markerfacecolor='gray', \n",
        "               markersize=8, alpha=0.6, label='未选中质心'),\n",
        "        Line2D([0], [0], color='red', linewidth=2, label='选中距离'),\n",
        "        Line2D([0], [0], color='gray', linestyle=':', alpha=0.5, label='未选中距离')\n",
        "    ]\n",
        "    plt.legend(handles=legend_elements, fontsize=7, loc='upper right')\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    # 4. 精细搜索\n",
        "    plt.subplot(2, 3, 4)\n",
        "    \n",
        "    # 背景：显示所有数据点（淡化）\n",
        "    plt.scatter(data[:, 0], data[:, 1], c='lightgray', alpha=0.2, s=10)\n",
        "    \n",
        "    # 显示选中的质心\n",
        "    for cluster_idx in nearest_cluster_indices:\n",
        "        plt.scatter(ivf.centroids[cluster_idx, 0], ivf.centroids[cluster_idx, 1], \n",
        "                   c='red', marker='X', s=100, linewidths=2, edgecolors='darkred', alpha=0.8)\n",
        "    \n",
        "    # 收集并按簇显示候选向量\n",
        "    candidate_indices = []\n",
        "    cluster_colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']\n",
        "    \n",
        "    for i, cluster_idx in enumerate(nearest_cluster_indices):\n",
        "        cluster_candidates = ivf.inverted_lists[cluster_idx]\n",
        "        candidate_indices.extend(cluster_candidates)\n",
        "        \n",
        "        # 用不同颜色显示不同簇的候选向量\n",
        "        cluster_data = data[cluster_candidates]\n",
        "        plt.scatter(cluster_data[:, 0], cluster_data[:, 1], \n",
        "                   c=cluster_colors[i % len(cluster_colors)], alpha=0.7, s=30,\n",
        "                   label=f'簇{cluster_idx}候选({len(cluster_candidates)}个)', \n",
        "                   edgecolors='black', linewidths=0.5)\n",
        "    \n",
        "    # 查询点\n",
        "    plt.scatter(query[0], query[1], c='#FFD93D', marker='*', s=200, \n",
        "               edgecolors='black', linewidth=2, label='查询点', zorder=10)\n",
        "    \n",
        "    plt.title(f'4. 精细搜索：收集{len(candidate_indices)}个候选向量', fontweight='bold')\n",
        "    plt.legend(fontsize=7, loc='upper right')\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    # 5. IVF结果\n",
        "    plt.subplot(2, 3, 5)\n",
        "    plt.scatter(data[:, 0], data[:, 1], c='lightgray', alpha=0.4, s=20)\n",
        "    plt.scatter(data[ivf_results, 0], data[ivf_results, 1], \n",
        "               c='red', marker='o', s=60, edgecolors='darkred', \n",
        "               linewidth=2, label='IVF结果')\n",
        "    \n",
        "    for i, idx in enumerate(ivf_results[:5]):\n",
        "        plt.annotate(f'{i+1}', (data[idx, 0], data[idx, 1]), \n",
        "                    xytext=(3, 3), textcoords='offset points', \n",
        "                    fontsize=8, color='white', fontweight='bold')\n",
        "    \n",
        "    plt.scatter(query[0], query[1], c='#FFD93D', marker='*', s=150, \n",
        "               edgecolors='black', linewidth=2, label='查询点')\n",
        "    plt.title('5. IVF结果', fontweight='bold')\n",
        "    plt.legend(fontsize=8)\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    # 6. 结果对比\n",
        "    plt.subplot(2, 3, 6)\n",
        "    plt.scatter(data[:, 0], data[:, 1], c='lightgray', alpha=0.3, s=15)\n",
        "    plt.scatter(data[bf_results, 0], data[bf_results, 1], \n",
        "               c='green', marker='s', s=60, edgecolors='darkgreen', \n",
        "               linewidth=2, label='暴力搜索', alpha=0.7)\n",
        "    plt.scatter(data[ivf_results, 0], data[ivf_results, 1], \n",
        "               c='red', marker='o', s=50, alpha=0.8, label='IVF结果')\n",
        "    plt.scatter(query[0], query[1], c='#FFD93D', marker='*', s=150, \n",
        "               edgecolors='black', linewidth=2, label='查询点')\n",
        "    \n",
        "    # 计算召回率\n",
        "    intersection = set(ivf_results) & set(bf_results)\n",
        "    recall = len(intersection) / len(bf_results)\n",
        "    \n",
        "    plt.title(f'6. 结果对比 (召回率: {recall:.1%})', fontweight='bold')\n",
        "    plt.legend(fontsize=8)\n",
        "    plt.grid(True, alpha=0.3)\n",
        "    \n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "    \n",
        "    # 简化的统计信息\n",
        "    total_candidates = sum(len(ivf.inverted_lists[i]) for i in nearest_cluster_indices)\n",
        "    search_ratio = total_candidates / len(data)\n",
        "    \n",
        "    print(f\"\\nIVF算法统计:\")\n",
        "    print(f\"数据量: {len(data)} 个向量\")\n",
        "    print(f\"聚类数: {ivf.n_clusters} 个簇\")\n",
        "    print(f\"搜索簇: {ivf.n_probe} 个簇\")\n",
        "    print(f\"候选向量: {total_candidates} 个 ({search_ratio:.1%})\")\n",
        "    print(f\"召回率: {recall:.1%}\")\n",
        "    \n",
        "    return recall\n",
        "\n",
        "\n",
        "#用少量样本进行可视化\n",
        "ivf_tiny, data_tiny, query_tiny, ivf_results_tiny, bf_results_tiny = demonstrate_ivf(data_size=100)\n",
        "recall = visualize_ivf(ivf_tiny, data_tiny, query_tiny, ivf_results_tiny, bf_results_tiny)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "开始训练IVF索引...\n",
            "训练完成，得到5个簇\n",
            "倒排索引构建完成「展示前5个簇」:\n",
            "  簇4: 333个向量\n",
            "  簇1: 100个向量\n",
            "  簇2: 110个向量\n",
            "  簇3: 123个向量\n",
            "  簇0: 334个向量\n",
            "开始训练IVF索引...\n",
            "训练完成，得到5个簇\n",
            "倒排索引构建完成「展示前5个簇」:\n",
            "  簇0: 170个向量\n",
            "  簇1: 163个向量\n",
            "  簇3: 333个向量\n",
            "  簇4: 150个向量\n",
            "  簇2: 184个向量\n",
            "开始训练IVF索引...\n",
            "训练完成，得到5个簇\n",
            "倒排索引构建完成「展示前5个簇」:\n",
            "  簇0: 333个向量\n",
            "  簇2: 153个向量\n",
            "  簇1: 180个向量\n",
            "  簇4: 191个向量\n",
            "  簇3: 143个向量\n",
            "\n",
            "==================================================\n",
            "n_probe参数影响分析\n",
            "==================================================\n",
            "n_probe=1: 召回率=80.0%, 耗时=0.001708秒, 搜索向量数=334\n",
            "n_probe=2: 召回率=80.0%, 耗时=0.000682秒, 搜索向量数=333\n",
            "n_probe=3: 召回率=100.0%, 耗时=0.000797秒, 搜索向量数=666\n"
          ]
        }
      ],
      "source": [
        "def analyze_parameters():\n",
        "    \"\"\"分析n_probe参数对搜索效果的影响\"\"\"\n",
        "    data = generate_sample_data(1000, 2)\n",
        "    query = np.array([5.0, 5.0])\n",
        "    \n",
        "    n_probe_values = [1, 2, 3]\n",
        "    results = []\n",
        "    \n",
        "    for n_probe in n_probe_values:\n",
        "        ivf = SimpleIVF(n_clusters=5, n_probe=n_probe)\n",
        "        ivf.data = data\n",
        "        ivf.build_index(data)\n",
        "        \n",
        "        # IVF搜索\n",
        "        start_time = time.time()\n",
        "        ivf_indices, _ = ivf.search(query, k=5, data=data)\n",
        "        ivf_time = time.time() - start_time\n",
        "        \n",
        "        # 暴力搜索作为基准\n",
        "        bf_indices, _ = ivf.brute_force_search(query, k=5, data=data)\n",
        "        \n",
        "        # 计算召回率\n",
        "        intersection = set(ivf_indices) & set(bf_indices)\n",
        "        recall = len(intersection) / len(bf_indices)\n",
        "        \n",
        "        results.append({\n",
        "            'n_probe': n_probe,\n",
        "            'recall': recall,\n",
        "            'time': ivf_time,\n",
        "            'candidates_searched': sum(len(ivf.inverted_lists[i]) \n",
        "                                    for i in range(n_probe))\n",
        "        })\n",
        "    \n",
        "    # 显示结果\n",
        "    print(\"\\n\" + \"=\"*50)\n",
        "    print(\"n_probe参数影响分析\")\n",
        "    print(\"=\"*50)\n",
        "    \n",
        "    for result in results:\n",
        "        print(f\"n_probe={result['n_probe']}: \"\n",
        "              f\"召回率={result['recall']:.1%}, \"\n",
        "              f\"耗时={result['time']:.6f}秒, \"\n",
        "              f\"搜索向量数={result['candidates_searched']}\")\n",
        "    \n",
        "    return results\n",
        "\n",
        "# 运行参数分析\n",
        "parameter_results = analyze_parameters()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "**⚖️ 第六步：参数影响分析**\n",
        "\n",
        "让我们分析n_probe参数对搜索效果的影响："
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "从结论我们可以发现​速度与精度的基本权衡关系​​\n",
        "1.从 n_probe=2到 n_probe=3的变化，完美体现了IVF算法中​​速度与精度的经典权衡​​。\n",
        "- 当 n_probe从2增加到3时，搜索的簇数量增加，因此需要计算的向量数量几乎翻倍（从333增加到666）。这导致搜索范围扩大，从而​​召回率从80%提升到了100%​​，但代价是​​耗时也有所增加​​（从0.000682秒增加到0.000797秒）。\n",
        "这说明，​​增大 n_probe通常能以牺牲速度为代价来提升召回率​​。\n",
        "\n",
        "​2.​发现异常点：n_probe=1的性能反常​​\n",
        "这是一个非常关键的发现，这理论上，n_probe=1（只搜索1个最近的簇）应该是最快的，但结果却显示它​​最慢（0.001708秒）​​。\n",
        "- 在 n_probe=1时，由于编程语言（如Python）的解释器开销、缓存未命中或其他偶然因素所致，你多尝试几次会发现n_probe=1的时间会有波动，这就是编译器本身编译或者缓存导致\n",
        "​\n",
        "最后，可以总结出以下核心要点：\n",
        "\n",
        "- 基本规律成立​​：n_probe增大，搜索范围扩大，召回率提高，但耗时增加。\n",
        "- ​​实践出真知​​：理论规律需要在实际测试中验证。实验中可能会出现像 n_probe=1这样的性能异常点，这正体现了参数调优和基准测试的重要性。\n",
        "- ​​没有“最好”的参数，只有“最合适”的参数​​：最终的参数选择取决于应用场景对​​速度​​和​​精度​​的具体要求。"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.18"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
